home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 2.toast / pc / sample code / interapplication comm / menuscripter / sources / mswindow.c < prev    next >
Encoding:
Text File  |  2000-06-23  |  25.1 KB  |  1,084 lines
  1. // MSWindow.c
  2. //
  3. // Original version by Jon Lansdell and Nigel Humphreys.
  4. // 4.0 and 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1996, all rights reserved.
  6.  
  7. /*
  8.     Changes for 3.1 :
  9.     
  10.     12-Oct-95 : CW : Cleaned up DoContent and added call to DoWindowContentDrag
  11.                      Clean up CloseMyWindow and added call to RemoveDragHandlers
  12.                      Added InstallDragHandlers call to NewDocument
  13.                      Use HiliteControl on suspend/resume instead of Show/HideControl
  14.     1-Nov-95  : DS : Made Changes for GX Printing.
  15.  
  16.     Changes for 4.0 :
  17.  
  18.     17-Apr-96 : GS : Changed pascal calling conventions to C where possible.
  19. */
  20.  
  21. #include <Scrap.h>
  22. #include <Packages.h>
  23. #ifdef THINK_C
  24.     #include "PLStrs.h"
  25. #else
  26.     #include <PLStringFuncs.h>
  27. #endif
  28. #include <GXPrinting.h>
  29. #include <PrintingMessages.h>
  30.  
  31. #include "MSWindow.h"
  32. #include "MSMain.h"
  33. #include "MSDrag.h"
  34. #include "MSAERecording.h"
  35. #include "MSGXPrinting.h"
  36. #include "MSResultWind.h"
  37. #include "MSAEWindowUtils.h"
  38.  
  39. #define    kControlInvisible        0
  40. #define    kControlVisible            0xFF             
  41. #define    kScrollbarWidth            16
  42. #define    kScrollbarAdjust        (kScrollbarWidth - 1)
  43. #define    kScrollTweek            2
  44. #define    kTextOffset                5 
  45. #define    kButtonScroll            10
  46.             
  47. #define    kHOffset                20   // Stagger window offsets
  48. #define    kVOffset                20
  49.             
  50. #define    kTBarHeight                20
  51. #define    kMBarHeight                20
  52.  
  53. #pragma segment Window
  54.  
  55. DPtr    DPtrFromWindowPtr(WindowPtr theWindow)
  56. {
  57.     if ( theWindow && IsDocumentWindow( theWindow ) )
  58.         return((DPtr)GetWRefCon(theWindow));
  59.     else
  60.         return(NULL);
  61. } // DPtrFromWindowPtr
  62.  
  63.     
  64. #pragma segment main
  65.  
  66.  
  67. //  Scroll the TERec around to match up to the potentially updated scrollbar
  68. //  values. This is really useful when the window resizes such that the
  69. //  scrollbars become inactive and the TERec had been previously scrolled.
  70.  
  71. void    AdjustTE( DPtr theDoc )
  72. {
  73.     short    h;
  74.     short    v;
  75.     TEHandle myText;
  76.     
  77.     myText = theDoc->theText;
  78.     h = ((*myText)->viewRect.left - (*myText)->destRect.left) -
  79.     GetCtlValue(theDoc->hScrollBar) + kTextOffset;
  80.              
  81.     v = ((*myText)->viewRect.top - (*myText)->destRect.top) - 
  82.     GetCtlValue(theDoc->vScrollBar) + kTextOffset;
  83.                      
  84.     if (h || v)
  85.     {
  86.         TEScroll(h, v, theDoc->theText);
  87.         DrawPageExtras(theDoc);
  88.     }
  89. } // AdjustTE
  90.     
  91.     
  92. // Calculate the new control maximum value and current value, whether it is the horizontal or
  93. // vertical scrollbar. The vertical max is calculated by comparing the number of lines to the
  94. // vertical size of the viewRect. The horizontal max is calculated by comparing the maximum document
  95. // width to the width of the viewRect. The current values are set by comparing the offset between
  96. // the view and destination rects. If necessary and we canRedraw, have the control be re-drawn by
  97. // calling ShowControl.
  98.  
  99. // TEStyleSample-vertical max originally used line by line calculations-lineheight was a
  100. // constant value so it was easy to figure out what the range should be and pin the value
  101. // within range. Now we need to use max and min values in pixels rather than in nlines.
  102.  
  103. #pragma segment main
  104.  
  105. void    AdjustHV( Boolean isVert, ControlHandle control, DPtr theDoc, Boolean canRedraw )
  106. {
  107.     TEHandle    docTE;
  108.     short       value;
  109.     short        max;
  110.     short        oldValue;
  111.     short        oldMax;
  112.     Rect        sizeRect;
  113.     
  114.     GetRectOfPage( theDoc, &sizeRect );
  115.     docTE    = theDoc->theText;
  116.     
  117.     oldValue = GetCtlValue(control);
  118.     oldMax   = GetCtlMax(control);
  119.     if (isVert)
  120.     {
  121.         // new for TEStyleSample
  122.         max = TEGetHeight((*docTE)->nLines, 0, docTE) -
  123.                    ((*docTE)->viewRect.bottom - (*docTE)->viewRect.top);
  124.     
  125.     }
  126.     else
  127.         max = sizeRect.right - ((*docTE)->viewRect.right - (*docTE)->viewRect.left);
  128.             
  129.     max += kTextOffset + kTextOffset; // Allow over scroll by kTextOffset
  130.             
  131.     if (max < 0)
  132.     max = 0; // check for negative values
  133.         
  134.     SetCtlMax(control, max);
  135.     
  136.     if (isVert)
  137.         value = (*docTE)->viewRect.top - (*docTE)->destRect.top;
  138.     else
  139.         value = (*docTE)->viewRect.left - (*docTE)->destRect.left;
  140.                 
  141.     value += kTextOffset;
  142.             
  143.     if (value < 0)
  144.         value = 0;
  145.     else
  146.         if (value > max)
  147.             value = max; // pin the value to within range
  148.                     
  149.     SetCtlValue(control, value);
  150.     if (canRedraw && ((max != oldMax) || (value != oldValue)))
  151.         ShowControl(control); // check to see if the control can be re-drawn
  152. } // AdjustHV
  153.  
  154.  
  155. #pragma segment Main
  156.  
  157. // Simply call the common adjust routine for the vertical and horizontal scrollbars.
  158.  
  159. void    AdjustScrollValues( DPtr theDoc, Boolean canRedraw )
  160. {        
  161.     AdjustHV(true,  theDoc->vScrollBar, theDoc, canRedraw);
  162.     AdjustHV(false, theDoc->hScrollBar, theDoc, canRedraw);
  163. } // AdjustScrollValues
  164.  
  165.  
  166. // Return a rectangle that is inset from the portRect by the size of
  167. //  the scrollbars and a little extra margin.
  168.  
  169. void    GetTERect( WindowPtr window, Rect *teRect )
  170. {
  171.     *teRect = window->portRect;
  172.     (*teRect).bottom -= kScrollbarAdjust; // and for the scrollbars
  173.     (*teRect).right  -= kScrollbarAdjust;
  174. } // GetTERect
  175.  
  176.  
  177. // Re-calculate the position and size of the viewRect and the scrollbars.
  178. //  kScrollTweek compensates for off-by-one requirements of the scrollbars
  179. //  to have borders coincide with the growbox.
  180.  
  181. void    AdjustScrollSizes( DPtr theDoc )
  182. {  
  183.     Rect    teRect;
  184.     Rect    myPortRect;
  185.     
  186.     GetTERect(theDoc->theWindow, &teRect); // start with teRect
  187.     myPortRect = theDoc->theWindow->portRect;
  188.     
  189.     (*(theDoc->theText))->viewRect = teRect;
  190.     
  191.     MoveControl(theDoc->vScrollBar, myPortRect.right - kScrollbarAdjust, - 1);
  192.     SizeControl(theDoc->vScrollBar, 
  193.                  kScrollbarWidth, 
  194.                      (myPortRect.bottom - myPortRect.top) - (kScrollbarAdjust - kScrollTweek));
  195.         
  196.     MoveControl(theDoc->hScrollBar, - 1, myPortRect.bottom - kScrollbarAdjust);
  197.     SizeControl(theDoc->hScrollBar,
  198.                     (myPortRect.right - myPortRect.left) - (kScrollbarAdjust - kScrollTweek),
  199.                         kScrollbarWidth);
  200. } // AdjustScrollSizes
  201.  
  202. #pragma segment Window
  203.  
  204. // Turn off the controls by jamming a zero into their contrlVis fields
  205. //  (HideControl erases them and we don't want that). If the controls are to
  206. //  be resized as well, call the procedure to do that, then call the procedure
  207. //  to adjust the maximum and current values. Finally reset the controls
  208. //  to be visible if not in background.
  209.  
  210. void    AdjustScrollbars( DPtr theDoc, Boolean  needsResize )
  211. {
  212.     (*(theDoc->vScrollBar))->contrlVis = kControlInvisible; // turn them off
  213.     (*(theDoc->hScrollBar))->contrlVis = kControlInvisible;
  214.     
  215.     if (needsResize) // move and size if needed
  216.     AdjustScrollSizes(theDoc);
  217.     
  218.     AdjustScrollValues(theDoc, !needsResize); // fool with max and current value
  219.     
  220.     // Now, restore visibility in case we never had to ShowControl during adjustment
  221.     
  222.     if (!gInBackground)
  223.     {
  224.         (*(theDoc->vScrollBar))->contrlVis = kControlVisible; // turn them on
  225.         (*(theDoc->hScrollBar))->contrlVis = kControlVisible;
  226.     }
  227.     else
  228.     {         // make sure they stay invisible
  229.         if ((*(theDoc->vScrollBar))->contrlVis)
  230.             HideControl(theDoc->vScrollBar);
  231.         if ((*(theDoc->vScrollBar))->contrlVis)
  232.             HideControl(theDoc->hScrollBar);
  233.     }
  234. } // AdjustScrollbars
  235.  
  236.  
  237. #pragma segment Window
  238.  
  239. void    GetWinContentRect( WindowPtr theWindow, Rect *r )
  240. {
  241.     *r         = theWindow->portRect;
  242.     r->right  -= kScrollbarAdjust;
  243.     r->bottom -= kScrollbarAdjust;
  244. } // GetWinContentRect
  245.  
  246.     
  247. #pragma segment Window
  248.         
  249. void    InvalidateDocument( DPtr theDoc )
  250. {
  251.     GrafPtr oldPort;
  252.         
  253.     GetPort(&oldPort);
  254.     SetPort(theDoc->theWindow);
  255.     InvalRect(&theDoc->theWindow->portRect);
  256.     SetPort(oldPort);
  257. } 
  258.                         
  259.  
  260. // Called when the window has been resized to fix up the controls and content.
  261.  
  262. void    ResizeWindow( DPtr theDoc )
  263. {
  264.     AdjustScrollbars(theDoc, true);
  265.     AdjustTE(theDoc);
  266.     InvalidateDocument(theDoc);
  267. } // ResizeWindow
  268.  
  269.  
  270. // Called when the window has been resized to fix up the controls and content
  271.  
  272. void    ResizePageSetupForDocument( DPtr theDoc )
  273. {
  274.     Rect pageRect;
  275.     
  276.     GetRectOfPage( theDoc, &pageRect );
  277.     (*(theDoc->theText))->destRect.right = (*(theDoc->theText))->destRect.left + pageRect.right;
  278.     TECalText(theDoc->theText);
  279.     
  280.     ResizeWindow(theDoc);
  281. } // ResizePageSetupForDocument
  282.  
  283.  
  284. #pragma segment Main
  285.  
  286. // Common algorithm for setting the new value of a control. It returns the actual amount
  287. //  the value of the control changed. Note the pinning is done for the sake of returning
  288. //  the amount the control value changed.
  289.  
  290. void    CommonAction( ControlHandle control, short *amount )
  291. {
  292.     short   value;
  293.     short   max;
  294.     
  295.     value   = GetCtlValue(control); // get current value
  296.     max     = GetCtlMax(control);    // and max value
  297.     *amount = value - *amount;
  298.     if (*amount < 0)
  299.         *amount = 0;
  300.     else if (*amount > max)
  301.         *amount = max;
  302.     
  303.     SetCtlValue(control, *amount);
  304.     *amount = value - *amount;        // calculate true change
  305. } // CommonAction
  306.  
  307.  
  308. #pragma segment Main
  309.  
  310. // Determines how much to change the value of the vertical scrollbar by and how
  311. //  much to scroll the TE record.
  312.  
  313. pascal void VActionProc( ControlHandle control, short part )
  314. {
  315.     short           amount;
  316.     WindowPtr       window;
  317.     DPtr            theDoc;
  318.     
  319.     if ( part )
  320.     {
  321.         window = (*control)->contrlOwner;
  322.         theDoc = DPtrFromWindowPtr(window);
  323.         switch (part)
  324.         {
  325.             case inUpButton:
  326.             case inDownButton:
  327.                 amount = 24;
  328.                 break;
  329.                 
  330.             case inPageUp:
  331.             case inPageDown:
  332.                 amount = (*(theDoc->theText))->viewRect.bottom - 
  333.                                  (*(theDoc->theText))->viewRect.top;
  334.                 break;
  335.         } // case
  336.         
  337.         if (part == inDownButton || part == inPageDown)
  338.         amount = -amount; // reverse direction
  339.         
  340.         CommonAction(control, &amount);
  341.         
  342.         if (amount)
  343.         {
  344.             TEScroll(0, amount, theDoc->theText);
  345.             DrawPageExtras(theDoc);
  346.         }
  347.     } // if
  348. } // VActionProc
  349.  
  350.  
  351. #pragma segment Main
  352.  
  353. // Determines how much to change the value of the horizontal scrollbar by and how
  354. //  much to scroll the TE record.
  355.  
  356. pascal void HActionProc(ControlHandle control, short part)
  357. {
  358.     short      amount;
  359.     WindowPtr  window;
  360.     DPtr       theDoc;
  361.     
  362.     if ( part )
  363.     {
  364.         window = (*control)->contrlOwner;
  365.         theDoc = DPtrFromWindowPtr(window);
  366.         switch ( part )
  367.         {
  368.             case inUpButton:
  369.             case inDownButton:
  370.                 amount = kButtonScroll; // a few pixels
  371.                 break;
  372.                 
  373.             case inPageUp:
  374.             case inPageDown:
  375.                 amount = (*(theDoc->theText))->viewRect.right - 
  376.                             (*(theDoc->theText))->viewRect.left; // a page
  377.                 break;
  378.         } // switch
  379.  
  380.         if (part == inDownButton || part == inPageDown)
  381.         amount = - amount; // reverse direction
  382.         
  383.         CommonAction(control, &amount);
  384.         if (amount)
  385.         {
  386.             TEScroll(amount, 0, theDoc->theText);
  387.             DrawPageExtras(theDoc);
  388.         }
  389.     } // if
  390. } // HActionProc
  391.  
  392.  
  393. //        Name:             ShowSelect
  394. //        Purpose:        Scrolls the text selection into view.
  395.  
  396. #pragma segment Window
  397.  
  398. void    ShowSelect( DPtr theDoc )
  399. {
  400.     AdjustScrollbars(theDoc, false);
  401.     
  402.         //    Let TextEdit do the hard work of keeping the selection visible…
  403.     
  404.     TEAutoView(true, theDoc->theText);
  405.     TESelView(theDoc->theText);
  406.     TEAutoView(false, theDoc->theText);
  407.     
  408.         //    Now rematch the text and the scrollbars…
  409.     
  410.     SetCtlValue(theDoc->hScrollBar,
  411.                     (*(theDoc->theText))->viewRect.left - 
  412.                         (*(theDoc->theText))->destRect.left + kTextOffset);
  413.     
  414.     SetCtlValue(theDoc->vScrollBar,
  415.                     (*(theDoc->theText))->viewRect.top - 
  416.                         (*(theDoc->theText))->destRect.top  + kTextOffset);
  417. } // ShowSelect
  418.  
  419.  
  420. #pragma segment Window
  421.  
  422. void    OffsetWindow( WindowPtr aWindow )
  423. {
  424.     short    theWidth;
  425.     short    theHeight;
  426.     short    theHScreen;
  427.     short    theVScreen;
  428.     short    xWidth;
  429.     short    xHeight;
  430.     short    hMax;
  431.     short    vMax;
  432.     short    wLeft;
  433.     short    wTop;
  434.     long    docCount;
  435.      
  436.     theWidth  = aWindow->portRect.right - aWindow->portRect.left;
  437.     theHeight = aWindow->portRect.bottom - aWindow->portRect.top + kTBarHeight;
  438.     
  439.     theHScreen = qd.screenBits.bounds.right  - qd.screenBits.bounds.left;
  440.     theVScreen = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top;
  441.     
  442.     xWidth  = theHScreen - theWidth;
  443.     xHeight = theVScreen - (theHeight + kMBarHeight);
  444.     
  445.     hMax = (xWidth / kVOffset) + 1;
  446.     vMax = (xHeight / kVOffset) + 1;
  447.     
  448.     docCount = CountDocuments( );
  449.     if ( ! IsVisible( aWindow ) )
  450.         docCount++;        // Offset has been called on a window still hidden
  451.     
  452.     wLeft = ( docCount % hMax ) * kVOffset;
  453.     wTop  = ( ( docCount % vMax ) * kVOffset ) + kTBarHeight + kMBarHeight;
  454.     
  455.     MoveWindow(aWindow, wLeft, wTop, false);
  456. }
  457.  
  458. /*
  459. // Returns the update region in local coordinates.
  460.  
  461. void    GetLocalUpdateRgn( WindowPtr window, RgnHandle localRgn )
  462. {
  463.     CopyRgn(((WindowPeek)window)->updateRgn, localRgn); // save old update region
  464.     OffsetRgn(localRgn,
  465.                 window->portBits.bounds.left, 
  466.                     window->portBits.bounds.top); // convert to local coords
  467. } // GetLocalUpdateRgn
  468. */
  469.  
  470. #pragma segment Window
  471.  
  472. void    MyGrowWindow( WindowPtr w, Point p )
  473. {
  474.     GrafPtr savePort;
  475.     long    theResult;
  476.     Rect    r;
  477.     
  478.     GetPort(&savePort);
  479.     SetPort(w);
  480.     SetRect(&r, 80, 80, qd.screenBits.bounds.right, qd.screenBits.bounds.bottom);
  481.     theResult = GrowWindow(w, p, &r);
  482.     if (theResult)
  483.         IssueSizeWindow(w, LoWord(theResult), HiWord(theResult));
  484.     
  485.     SetPort(savePort);
  486. }
  487.  
  488.  
  489. #pragma segment Window
  490.  
  491. // Because windows can be hidden we must check for menu changes
  492.  
  493. void ShowMSWindow( WindowPtr theWindow )
  494. {
  495.     ShowWindow( theWindow );
  496.     if ( FrontWindow( ) == theWindow )
  497.     {
  498.         DoActivate( GetNthWindow( 2 ), false );
  499.         DoActivate( theWindow, true );
  500.     }
  501.     CheckMenus( );
  502. }
  503.  
  504. void HideMSWindow( WindowPtr theWindow )
  505. {
  506.     Boolean        fActivate;
  507.  
  508.     fActivate = ( FrontWindow( ) == theWindow );
  509.     HideWindow( theWindow );
  510.     if ( fActivate )
  511.     {
  512.         DoActivate( theWindow, false );
  513.         DoActivate( GetNthWindow( 1 ), true );
  514.     }
  515.     
  516.     CheckMenus( );
  517. }
  518.  
  519. #pragma segment Window
  520.  
  521. void    DoZoom( WindowPtr w, short c, Point p )
  522. {
  523.     GrafPtr savePort;
  524.     
  525.     GetPort(&savePort);
  526.     SetPort(w);
  527.     if (TrackBox(w, p, c))
  528.     {
  529.         EraseRect(&w->portRect);
  530.         IssueZoomCommand(w, c);
  531.     }
  532. }
  533.  
  534. #pragma segment Window
  535.  
  536. void    DoContent( WindowPtr theWindow, EventRecord theEvent )
  537. {
  538.     short            cntlCode;
  539.     short            part;
  540.     short            value;
  541.     ControlHandle    theControl;
  542.     GrafPtr            savePort;
  543.     Boolean            extend;
  544.     DPtr            theDoc;
  545.     Point            localPt;
  546.     
  547.     
  548.     GetPort ( &savePort );
  549.     SetPort ( theWindow );
  550.     theDoc = DPtrFromWindowPtr ( theWindow );
  551.     
  552.     localPt = theEvent.where;
  553.     GlobalToLocal ( &localPt );
  554.     cntlCode = FindControl ( localPt, theWindow, &theControl );
  555.     if ( cntlCode == 0 )
  556.     {
  557.         if ( UserWantsToDrag ( theWindow, theEvent.where ) )
  558.         {
  559.             if ( DoWindowContentDrag ( theWindow, &theEvent ) )
  560.                 TEClick ( localPt, false, theDoc->theText );
  561.         }
  562.         else
  563.         {
  564.             // only extend the selection if the shiftkey is down
  565.             extend = (theEvent.modifiers & shiftKey);
  566.             if ( PtInDocument ( localPt, theDoc ) )
  567.                 TEClick ( localPt, extend, theDoc->theText );
  568.         }
  569.     }
  570.     else if ( cntlCode == inThumb )
  571.     {
  572.         value = GetCtlValue(theControl);
  573.         part  = TrackControl(theControl, localPt, nil);
  574.         if (part)
  575.         {
  576.             value -= GetCtlValue(theControl);
  577.             if (value)
  578.             {
  579.                 if (theControl == theDoc->vScrollBar)
  580.                     TEScroll(0, value, theDoc->theText);
  581.                 else
  582.                     TEScroll(value, 0, theDoc->theText);
  583.                 DrawPageExtras(theDoc);
  584.             }
  585.         }
  586.     }
  587.     else
  588.     {
  589.         if (theControl == theDoc->vScrollBar)
  590.             part = TrackControl(theControl, localPt, (ControlActionUPP) gVScrollActionUPP);
  591.         else
  592.             part = TrackControl(theControl, localPt, (ControlActionUPP) gHScrollActionUPP);
  593.     }
  594.  
  595.     SetPort(savePort);
  596. }
  597.  
  598.  
  599.  
  600. void    DoBackgroundContent( WindowPtr theWindow, EventRecord theEvent)
  601. {
  602.     Point            thePoint;
  603.     GrafPtr            savePort;
  604.     RgnHandle        dragRgn;
  605.     DPtr              theDoc;
  606.  
  607.     GetPort ( &savePort );
  608.     SetPort ( theWindow );
  609.     theDoc = DPtrFromWindowPtr ( theWindow );
  610.     thePoint = theEvent.where;
  611.     GlobalToLocal ( &thePoint );
  612.     
  613.     
  614.     dragRgn = NewRgn ( );
  615.     GetSelectedTextRgn ( theDoc, dragRgn );
  616.     if ( PtInRgn ( thePoint, dragRgn ) )
  617.     {
  618.         if ( DoWindowContentDrag ( theWindow, &theEvent ) )
  619.             SelectWindow (theWindow );
  620.     }
  621.     else
  622.         SelectWindow ( theWindow );
  623.     
  624.     SetPort ( savePort );
  625.  
  626.     return;
  627. }
  628.  
  629. #pragma segment Window
  630.  
  631.  
  632. OSErr    DoActivate( WindowPtr theWindow, Boolean activate )
  633. {
  634.     Rect  r;
  635.     DPtr  theDoc;
  636.     OSErr err = noErr;
  637.         
  638.     if (theWindow)
  639.         if (Ours(theWindow))
  640.         {
  641.             theDoc = DPtrFromWindowPtr(theWindow);
  642.             SetPort(theWindow);
  643.             DrawGrowIcon(theWindow);
  644.             GetWinContentRect(theWindow, &r);
  645.             InvalRect(&r);
  646.             if ( activate )
  647.             {
  648.                 if ( theDoc->windowType == kOrdinaryWind )                        
  649.                     TEActivate(theDoc->theText);
  650.                 HiliteControl ( theDoc->vScrollBar, 0 );
  651.                 HiliteControl ( theDoc->hScrollBar, 0 );
  652.                 
  653.                 SetMenuItemState ( false, myMenus[editM], undoCommand );
  654.                 err = TEFromScrap();
  655.                 CheckMenus( );
  656.             }
  657.             else
  658.             {
  659.                 TEDeactivate( theDoc->theText );
  660.                 HiliteControl ( theDoc->vScrollBar, 255 );
  661.                 HiliteControl ( theDoc->hScrollBar, 255 );
  662.                 
  663.                 err = ZeroScrap();
  664.                 err = TEToScrap();
  665.             }
  666.         }
  667.  
  668.     return err;
  669. }
  670.  
  671. #pragma segment Window
  672.  
  673. void    GetPageEnds( short pageHeight, TEHandle theText,
  674.                                 PageEndsArray  pageBounds, short *nPages)
  675. {
  676.     short  pageBase;      // total pixel offset of pages so far
  677.     short  thisLine;
  678.     short  lastLine;
  679.     short  pageSoFar;
  680.     short  thisPage;      // Current page being calced
  681.     short  thisLineH;     // Height of text line
  682.     short  pageFirstLine; // Line # of top of page
  683.         
  684.     pageBase   = 0;
  685.     thisLine   = 1;
  686.     lastLine   = (*theText)->nLines;
  687.     
  688.     thisPage   = 0;
  689.     pageSoFar  = 0;
  690.     while ((thisLine <= lastLine) || (pageSoFar!=0))
  691.     {
  692.         pageFirstLine = thisLine;
  693.         thisLineH     = TEGetHeight(thisLine, thisLine, theText);
  694.         
  695.         while ((thisLineH+pageSoFar<pageHeight) && (thisLine <= lastLine))
  696.         {
  697.             pageSoFar += thisLineH;
  698.             thisLine++;
  699.             thisLineH = TEGetHeight(thisLine, thisLine, theText);
  700.         }
  701.             
  702.         if (pageSoFar)
  703.         {
  704.             pageBounds[thisPage] = pageSoFar+pageBase;
  705.             pageBase  = pageBounds[thisPage];
  706.             thisPage++;
  707.             pageSoFar = 0;
  708.         }
  709.             
  710.         //    Special case text line taller than page
  711.         
  712.         if ((thisLine  == pageFirstLine) &&
  713.              (thisLineH > pageHeight))
  714.             {
  715.                 do {
  716.                     pageBounds[thisPage] = pageBase+pageHeight;
  717.                     pageBase   = pageBounds[thisPage];
  718.                     thisPage  += 1;
  719.                     thisLineH -= pageHeight;
  720.                 } while (thisLineH >= pageHeight);
  721.                 pageSoFar = thisLineH;    // Carry bottom of large line to next page
  722.                 thisLine += 1;             // carry xs on as pageSoFar and start measuring next line
  723.             }
  724.     }
  725.         
  726.     *nPages = thisPage;
  727. } // GetPageEnds
  728.  
  729.  
  730. void    DrawPageBreaks( DPtr theDoc )
  731. {
  732.     PageEndsArray    pageEnds;
  733.     short           nPages;
  734.     short           ctr;
  735.     short           lineBase;
  736.     short           pageHeight;
  737.     Rect            viewRect;
  738.     Rect            pageRect;
  739.                 
  740.     GetRectOfPage( theDoc, &pageRect );
  741.     pageHeight = pageRect.bottom - pageRect.top;
  742.             
  743.     GetPageEnds(pageHeight, theDoc->theText, pageEnds, &nPages);
  744.                                         
  745.     lineBase = (*(theDoc->theText))->destRect.top;
  746.     viewRect = (*(theDoc->theText))->viewRect;
  747.     
  748.     PenPat(&qd.gray);
  749.     for (ctr = 0; ctr<nPages-1; ctr++)
  750.     {
  751.         MoveTo(viewRect.left, lineBase+pageEnds[ctr]);
  752.         LineTo(viewRect.right,lineBase+pageEnds[ctr]);
  753.     }
  754.  
  755.     PenNormal();
  756. } // DrawPageBreaks
  757.  
  758.         
  759. void    DrawPageExtras( DPtr theDoc )
  760. {
  761.     GrafPtr   oldPort;
  762.     RgnHandle    oldClip;
  763.     Rect          rectToClip;
  764.         
  765.     GetPort(&oldPort);
  766.     SetPort(theDoc->theWindow);
  767.             
  768.     oldClip = NewRgn();
  769.     GetClip(oldClip);
  770.             
  771.     GetWinContentRect(theDoc->theWindow,&rectToClip);
  772.     ClipRect(&rectToClip);
  773.                     
  774.         // and then the page breaks
  775.     DrawPageBreaks(theDoc);
  776.     
  777.     SetClip(oldClip);
  778.     
  779.     DisposeRgn(oldClip);
  780.     
  781.     SetPort(oldPort);
  782. } // DrawPageExtras
  783.  
  784.  
  785. void    DoUpdate( WindowPtr theWindow )
  786. {
  787.     GrafPtr        savePort;
  788.     Rect        rectClip;
  789.     DPtr        theDocument;
  790.     
  791.     
  792.     theDocument = DPtrFromWindowPtr ( theWindow );
  793.     if ( Ours ( theWindow ) )
  794.     {
  795.         GetPort ( &savePort );
  796.         SetPort ( theWindow );
  797.         BeginUpdate ( theWindow );
  798.         
  799.         ClipRect(&theWindow->portRect);
  800.         EraseRect(&theWindow->portRect);
  801.         DrawControls(theWindow);
  802.         DrawGrowIcon(theWindow);
  803.         
  804.         GetWinContentRect(theWindow, &rectClip);
  805.         ClipRect(&rectClip);
  806.         
  807.         TEUpdate(&theWindow->portRect, theDocument->theText);
  808.         
  809.         DrawPageExtras(theDocument);
  810.         
  811.         EndUpdate(theWindow);
  812.         ClipRect(&theWindow->portRect);
  813.         
  814.         SetPort ( savePort );
  815.     }
  816.     
  817.     return;
  818. } // DoUpdate
  819.  
  820.  
  821. #pragma segment Window
  822.  
  823. DPtr    NewDocument( Boolean isForOldDoc, WindowPtr behindWindow )
  824. {
  825.     Rect           destRect;
  826.     Rect           viewRect;
  827.     Rect           vScrollRect;
  828.     Rect           hScrollRect;
  829.     DPtr           myDoc;
  830.     WindowPtr      myWindow;
  831.     ControlHandle  vScroll;
  832.     ControlHandle  hScroll;
  833.     Str255         theName;
  834.     Str255         newNumber;
  835.     Rect           pageRect;
  836.  
  837.     myDoc = nil;
  838.     myWindow = GetNewWindow(WindowID, nil, behindWindow);
  839.     if (myWindow)
  840.     {
  841.         if (isForOldDoc==false)
  842.         {
  843.             GetWTitle(myWindow, theName);
  844.             NumToString(++gNewDocCount, newNumber);
  845.             if (gNewDocCount>1)
  846.             {
  847.                 PLstrcat(theName, (unsigned char *)"\p #");
  848.                 PLstrcat(theName, newNumber);
  849.                 SetWTitle(myWindow, theName);
  850.             }
  851.         }
  852.             
  853.         OffsetWindow(myWindow);
  854.  
  855.         SetPort(myWindow);
  856.  
  857.         myDoc = (DPtr)NewPtr(sizeof(DocRec));
  858.  
  859.         SetWRefCon(myWindow, (long)myDoc);
  860.  
  861.         myDoc->theWindow  = myWindow;
  862.         myDoc->windowType = kOrdinaryWind;
  863.  
  864.         vScrollRect = myWindow->portRect;
  865.  
  866.         vScrollRect.left  = vScrollRect.right - kScrollbarAdjust;
  867.         vScrollRect.right = vScrollRect.left  + kScrollbarWidth;
  868.  
  869.         vScrollRect.bottom = vScrollRect.bottom - 14;
  870.         vScrollRect.top    = vScrollRect.top - 1;
  871.         
  872.         vScroll = NewControl(myWindow, &vScrollRect, (unsigned char *)"\pScrollBar", true, 0, 0, 0, scrollBarProc, 0);
  873.  
  874.         hScrollRect = myWindow->portRect;
  875.         hScrollRect.top = hScrollRect.bottom - kScrollbarAdjust;
  876.         hScrollRect.bottom = hScrollRect.top + kScrollbarWidth;
  877.  
  878.         hScrollRect.right = hScrollRect.right - 14;
  879.         hScrollRect.left  = hScrollRect.left - 1;
  880.         hScroll = NewControl(myWindow, &hScrollRect, (unsigned char *)"\pScrollBar", true, 0, 0, 0, scrollBarProc, 0);
  881.  
  882.         myDoc->vScrollBar = vScroll;
  883.         myDoc->hScrollBar = hScroll;
  884.     
  885.         myDoc->dirty = false;
  886.  
  887.         GetTERect(myWindow, &viewRect);
  888.         destRect = viewRect;
  889.  
  890.         myDoc->theFont  = times;
  891.         myDoc->theStyle = 0;
  892.         myDoc->theSize  = 12;
  893.  
  894.         myDoc->documentJob   = nil;
  895.         myDoc->thePrintSetup = nil;
  896.         
  897.         if (gGXIsPresent)
  898.         {
  899.             if (GXNewJob(&(myDoc->documentJob)) == noErr)
  900.                 GXInstallApplicationOverride(myDoc->documentJob,
  901.                                              gxPrintingEventMsg,
  902.                                              NewGXPrintingEventProc(GXPrintingEventOverride));
  903.         }
  904.         else
  905.         {
  906.             myDoc->thePrintSetup = (THPrint)NewHandle(sizeof(TPrint));
  907.             
  908.             PrOpen();
  909.             PrintDefault(myDoc->thePrintSetup);
  910.             PrClose();
  911.         }
  912.     
  913.     
  914.         GetRectOfPage( myDoc, &pageRect );
  915.         destRect.right = destRect.left + pageRect.right;
  916.         
  917.         OffsetRect(&destRect, kTextOffset, kTextOffset);
  918.         
  919.         TextFont(times);
  920.         TextSize(12);
  921.         TextFace(0);
  922.  
  923.         myDoc->theText = TEStylNew(&destRect, &viewRect);
  924.  
  925. // SetClikLoop(@AutoScroll, myDoc->theText);
  926.  
  927.         myDoc->theFileName[0] = 0;
  928.         myDoc->everSaved      = false;
  929.         myDoc->theWindow      = myWindow;
  930.         ResizeWindow(myDoc);
  931.         
  932.         InstallDragHandlers ( myWindow );
  933.         
  934.         myDoc->theScriptID = kOSANullScript;
  935.     }
  936.  
  937.     return(myDoc);
  938. }
  939.  
  940.  
  941. #pragma segment Window
  942.  
  943. void    CloseMyWindow( WindowPtr aWindow )
  944. {
  945.     DPtr     aDocument;
  946.     TEHandle theText;
  947.  
  948.     if (IsThisResultWind(aWindow))
  949.         CloseResultWind(aWindow);
  950.     else
  951.     {
  952.         HideMSWindow(aWindow);
  953.         aDocument = DPtrFromWindowPtr(aWindow);
  954.         
  955.         theText = aDocument->theText;
  956.         TEDispose(theText);
  957.         
  958.         if (aDocument->thePrintSetup)
  959.             DisposHandle((Handle)aDocument->thePrintSetup);
  960.         
  961.         if (aDocument->documentJob)
  962.             GXDisposeJob(aDocument->documentJob);
  963.         
  964.         RemoveDragHandlers ( aWindow );
  965.         
  966.         DisposPtr((Ptr)aDocument);
  967.     
  968.         DisposeWindow(aWindow);
  969.     }
  970. }
  971.  
  972.             
  973. //        Name     :    PrintWindow
  974. //        Function :    Prints the document supplied in theDoc. askUser controls interaction
  975. //                       with the user.
  976. //                             
  977. //                    Uses extra memory equal to the size of the textedit use in the 
  978. //                     printed document.
  979.     
  980. void    PrintWindow( DPtr theDoc, Boolean askUser )
  981. {
  982.     GrafPtr            oldPort;
  983.     TEHandle        printerTE;
  984.     TPPrPort        printerPort;
  985.     Rect            printView;
  986.     PageEndsArray     pageBounds;
  987.     short            nPages;
  988.     short            pageCtr;
  989.     Boolean            abort;
  990.     Rect            rectToClip;
  991.     TPrStatus        thePrinterStatus;
  992.     DialogPtr        progressDialog;
  993.     WindowPtr       tempWind;                 // Temp window to create TERec in 
  994.     Rect            tempWindRect = {0,0,0,0}; // Bounds for temp window
  995.     abort = false;
  996.         
  997.  
  998.     //    Preserve the current port
  999.  
  1000.     GetPort(&oldPort);
  1001.     PrOpen();
  1002.         
  1003.     if (askUser)
  1004.         abort = !PrJobDialog(theDoc->thePrintSetup);
  1005.             
  1006.     if (abort)
  1007.     {
  1008.         PrClose();
  1009.         return;
  1010.     }
  1011.         
  1012.     progressDialog = GetNewDialog(1005, nil, (WindowPtr)-1);
  1013.         
  1014.     DrawDialog(progressDialog);
  1015.         
  1016.     printerPort = PrOpenDoc(theDoc->thePrintSetup, nil, nil);
  1017.     SetPort((GrafPtr)printerPort);
  1018.         
  1019.     // Create a temporary window(which is not shown)
  1020.     
  1021.     tempWind = NewWindow( nil, &tempWindRect, "\p",
  1022.                                 false, documentProc, (WindowPtr)-1, false, 0);
  1023.     
  1024.     // Duplicate the text edit rec
  1025.     printView = (*(theDoc->thePrintSetup))->prInfo.rPage;
  1026.     DuplicateStyleTERec ( theDoc->theText, &printerTE, &printView, (GrafPtr)tempWind );
  1027.     
  1028.     // Work out the offsets
  1029.     
  1030.     (*printerTE)->destRect = printView; // GetPageEnds calls TECalText
  1031.         
  1032.     GetPageEnds(printView.bottom-printView.top,
  1033.                             printerTE,
  1034.                             pageBounds,
  1035.                             &nPages);
  1036.         
  1037.     TEDeactivate(printerTE);
  1038.     
  1039.     // Set the TERec to the printer port
  1040.     (*printerTE)->inPort = (GrafPtr)printerPort;
  1041.     
  1042.     for (pageCtr = 0; pageCtr <= nPages-1; pageCtr++)
  1043.         if (!abort)
  1044.         {
  1045.             PrOpenPage(printerPort, nil);
  1046.                                         
  1047.             rectToClip = printView;
  1048.             
  1049.             if (pageCtr > 0)
  1050.                 rectToClip.bottom = rectToClip.top + (pageBounds[pageCtr]-pageBounds[pageCtr-1]);
  1051.             else
  1052.                 rectToClip.bottom = rectToClip.top + pageBounds[pageCtr];
  1053.                 
  1054.             ClipRect(&rectToClip);
  1055.             
  1056.             if (PrError() == iPrAbort)
  1057.                 abort = true;
  1058.                 
  1059.             if (! abort)
  1060.                 TEUpdate(&printView, printerTE);
  1061.                                     
  1062.             if (PrError() == iPrAbort)
  1063.                 abort = true;
  1064.                 
  1065.             PrClosePage(printerPort);
  1066.             
  1067.             TEScroll(0,rectToClip.top-rectToClip.bottom, printerTE);
  1068.         }
  1069.     
  1070.     TEDispose(printerTE);
  1071.     DisposeWindow ( tempWind );
  1072.     PrCloseDoc(printerPort);
  1073.     
  1074.     if (( (*(theDoc->thePrintSetup))->prJob.bJDocLoop == bSpoolLoop ) && 
  1075.             ( PrError() == noErr ) && (! abort))
  1076.         PrPicFile( theDoc->thePrintSetup, nil, nil, nil, &thePrinterStatus);
  1077.     
  1078.     PrClose();
  1079.     
  1080.     DisposDialog(progressDialog);
  1081.     
  1082.     SetPort(oldPort);
  1083.     InvalRect(&oldPort->portRect);
  1084. }